const express = require('express');
const router = express.Router();
const { Pool } = require('pg');
const bcrypt = require('bcryptjs');
// 初始化内存存储
let users = [];
let nextId = 1;
let pool = null;
let dbConnected = false;
// 初始化数据库连接函数 - 会在服务器启动后被调用
function initDatabaseConnection() {
  if (pool !== null) {
    console.log('数据库连接已初始化，跳过');
    return;
  }
  // 创建数据库连接池
  pool = new Pool({
    user: process.env.PG_USER,
    password: process.env.PG_PASSWORD,
    host: process.env.PG_HOST,
    port: parseInt(process.env.PG_PORT || '5432', 10),
    database: process.env.PG_DATABASE,
    ssl: process.env.PG_SSL === 'true'
  });
  // 错误处理
  pool.on('error', (err) => {
    console.error('数据库连接池错误:', err);
    console.log('将使用内存存储模式继续运行');
  });
  // 测试连接     
  pool.query('SELECT NOW()', (err, res) => {
    if (err) {
      console.error('数据库连接测试失败:', err.message);
      console.log('将使用内存存储模式继续运行');
    } else {
      dbConnected = true;
      console.log('auth数据库连接成功:', res.rows[0]);
    }
  });
}
// 登录接口
router.post('/login', async (req, res) => {
  try {
    const { username, password } = req.body;
    console.log('登录尝试:', username, '密码长度:', password ? password.length : 0);
    // 检查数据库连接
    if (dbConnected && pool) {
      try {
        console.log('尝试数据库登录...');
        const result = await pool.query(
          'SELECT id, username, password FROM users WHERE username = $1',
          [username]
        );
        console.log('数据库查询结果:', result.rows.length > 0 ? '找到用户' : '未找到用户');
        if (result.rows.length > 0) {
          const user = result.rows[0];
          console.log('数据库用户密码长度:', user.password ? user.password.length : 0);
          // 使用 bcryptjs 比较密码
          try {
            console.log('比较密码...');
            const passwordMatch = await bcrypt.compare(password, user.password);
            console.log('密码比较结果:', passwordMatch);
            if (passwordMatch) {
              const token = Buffer.from(JSON.stringify({ id: user.id, username: user.username })).toString('base64');
              console.log('数据库登录成功:', username); 
              return res.status(200).json({
                success: true,
                message: '登录成功 (数据库模式)',
                token,
                user: { id: user.id, username: user.username }
              });
            } else {
              console.log('数据库登录失败: 密码不匹配');
            }
          } catch (bcryptError) {
            console.error('bcrypt 比较错误:', bcryptError.message);
          }
        }
      } catch (dbError) {
        console.error('数据库查询错误:', dbError.message);
      }
    }
    // 说明所有登录尝试都失败了
    console.log('登录失败:', username, '用户不存在或密码错误');
    return res.status(401).json({ success: false, message: '用户名或密码错误' });
  } catch (error) {
    console.error('登录错误:', error);
    res.status(500).json({ success: false, message: '服务器错误' });
  }
});
// 注册接口 - 支持数据库和内存存储
router.post('/register', async (req, res) => {
  try {
    const { username, password } = req.body;
    console.log('注册请求:', { username, passwordLength: password?.length });
    
    // 查询用户是否已存在
    if (dbConnected) {
      const existingUser = await pool.query(
        'SELECT id FROM users WHERE username = $1',
        [username]
      );
      
      if (existingUser.rows.length > 0) {
        return res.status(400).json({
          success: false,
          message: '用户名已存在'
        });
      }
      
      // 使用bcrypt加密密码 - 确保正确使用
      const hashedPassword = await bcrypt.hash(password, 10);
      console.log('密码加密完成:', { hashedLength: hashedPassword.length });
      
      // 插入新用户
      const result = await pool.query(
        'INSERT INTO users (username, password, created_at, updated_at) VALUES ($1, $2, NOW(), NOW()) RETURNING id, username',
        [username, hashedPassword]
      );
      
      console.log('用户创建成功:', result.rows[0]);
      
      return res.status(201).json({
        success: true,
        message: '注册成功',
        user: { id: result.rows[0].id, username: result.rows[0].username }
      });
    } else {
      // 内存存储注册逻辑
      // 检查用户是否已存在
      if (users.some(u => u.username === username)) {
        console.log('用户名已存在(内存):', username);
        return res.status(400).json({ success: false, message: '用户名已存在' });
      }
      
      // 创建新用户
      const newUser = {
        id: nextId++,
        username,
        password
      };
      
      // 添加到内存存储
      users.push(newUser);
      console.log('内存注册成功:', username, '，当前用户数:', users.length);
      
      res.status(201).json({ 
        success: true, 
        message: '注册成功',
        user: {
          id: newUser.id,
          username: newUser.username
        }
      });
    }
  } catch (error) {
    console.error('注册错误:', error);
    res.status(500).json({ success: false, message: '服务器错误' });
  }
});
// 添加获取用户列表的路由
router.get('/users', async (req, res) => {
  try {
    if (dbConnected && pool) {
      const result = await pool.query('SELECT id, username, email, created_at FROM users');
      res.json(result.rows);
    } else {
      res.status(500).json({ message: '数据库未连接' });
    }
  } catch (error) {
    console.error('获取用户列表失败:', error);
    res.status(500).json({ message: '获取用户列表失败' });
  }
});
//添加编辑用户的路由
router.put('/users/:id', async (req, res) => {
  try {
    const { id } = req.params;
    const { username, email } = req.body;
    const result = await pool.query(
      'UPDATE users SET username = $1, email = $2 WHERE id = $3',
      [username, email, id]
    );
    res.json(result.rows[0]);
  } catch (error) {
    console.error('编辑用户失败:', error);
    res.status(500).json({ message: '编辑用户失败' });
  }
});




// 导出初始化函数和路由
module.exports = {
  router,
  initDatabaseConnection,
  pool: () => pool  // 导出一个获取pool的函数，避免引用问题
};